from platform import node
import random


class BiTreeNode:
    def __init__(self,data) -> None:
        self.data  = data
        self.lchild = None
        self.rchild = None
        self.parent = None

    def __repr__(self):
        return self.data

class BST:
    def __init__(self,li = None):
        self.root = None
        if li:
            for val in li:
                self.insert_no_rec(val)
    
    def insert(self,node,val):
        if not node:
            node = BiTreeNode(val)
        elif val < node.data:
            node.lchild = self.insert(node.lchild,val)
            node.lchild.parent = node
        elif val > node.data:
            node.rchild = self.insert(node.rchild,val)
            node.rchild.parent = node
        return node

    def insert_no_rec(self,val):
        p = self.root
        if not p:
            self.root = BiTreeNode(val)
            return
        
        while True: # 对比每一个节点 如果
            if val < p.data:
                if p.lchild:
                    p = p.lchild
                else:
                    p.lchild = BiTreeNode(val)
                    p.lchild.parent = p
                    return
            elif val > p.data:
                if p.rchild:
                    p = p.rchild
                else:
                    p.rchild = BiTreeNode(val)
                    p.rchild.parent = p
                    return
            else:
                return

    def query(self,node,val):
        if not node:
            return None
        if node.data < val:
            return self.query(node.lchild,val)
        elif node.data > val:
            return self.query(node.rchild,val)
        else:
            return node

    def query_no_rec(self,val):
        p = self.root
        while p:
            if p.data < val:
                p = p.rchild
            elif p.data > val:
                p = p.lchild
            else:
                return p
        return None
    
    def __remove_node_1(self,node):
        # 情况1 node是叶子节点
        if not node.parent:
            self.root = None
        if node == node.parent.lchild:
            node.parent.lchild = None
        else:
            node.parent.rchild = None
    
    def __remove_node_21(self,node):
        # 情况2.1 node只有一个左孩子
        if not node.parent:
            self.root = node.lchild
            node.lchild.parent = None
        elif node == node.parent.lchild:
            node.parent.lchild = node.lchild
            node.lchild.parent = None
        else:
            node.parent.rchild = node.lchild
            node.lchild.parent = None
    
    def __remove_node_22(self,node):
        # 情况2.2 node只有一个右孩子
        if not node.parent:
            self.root = node.rchild
            node.rchild.parent = None
        elif node == node.parent.lchild:
            node.parent.lchild = node.rchild
            node.rchild.parent = node.parent
        else :
            node.parent.rchild = node.rchild
            node.rchild.parent = node.parent
    
    def delete(self,val):
        if self.root: #不是空树
            node = self.query_no_rec(val)
            if not node: # 不存在
                return False
            if not node.lchild and node.rchild: #既没有左孩子 也没有右孩子
                self.__remove_node_1(val)
            elif not node.rchild: #只有左孩子
                self.__remove_node_21(val)
            elif not node.lchild: #只有右孩子
                self.__remove_node_22(val)
            else:
                # 两个孩子都有
                min_node = node.rchild
                while min_node.lchild:
                    min_node = min_node.lchild
                node.data = min_node.data
                # 删除min_node
                if min_node.rchild: #假如该节点有右孩子
                    self.__remove_node_22(min_node)
                else:# 假如该节点有左孩子
                    self.__remove_node_1(min_node)


    def pre_order(self,root):
        if root:
            print(root.data, end = ",")
            self.pre_order(root.lchild)
            self.pre_order(root.rchild)

    def in_order(self,root):
        if root:
            self.in_order(root.lchild)
            print(root.data, end = ",")
            self.in_order(root.rchild)

    def post_order(self,root):
        if root:
            self.post_order(root.lchild)
            self.post_order(root.rchild)
            print(root.data, end = ",")            
            
tree = BST([4,6,7,9,2,1,3,5,8])
tree.pre_order(tree.root)
print()
tree.in_order(tree.root)
print()
tree.post_order(tree.root)
print()


li = list(range(0,500,2))
random.shuffle(li)

tree = BST(li)
print(tree.query_no_rec(4).data)